e04ucf

Purpose

Synopsis

[iter,c,objf,objgrd,x,cjac,istate,clamda,r,ifail] = e04ucf(bl,bu,confun,...
objfun,x<,ncnln,a,cjac,istate,clamda,r,ifail>)

Description

 
 E04UCF is designed to solve the nonlinear programming problem -- 
 the minimization of a smooth nonlinear function subject to a set 
 of constraints on the variables. The problem is assumed to be 
 stated in the following form:
 
                                            { x  }           
        Minimize      F(x)   subject to  l<={A x }<=u,         (1)
                 n                          { L  }           
        x is in R                           {c(x)}           
 
 where F(x), the objective function, is a nonlinear function, A  
                                                               L
 is an n  by n constant matrix, and c(x) is an n  element vector 
        L                                       N               
 of nonlinear constraint functions. (The matrix A  and the vector 
                                                 L               
 c(x) may be empty.) The objective function and the constraint 
 functions are assumed to be smooth, i.e., at least twice-
 continuously differentiable. (The method of E04UCF will usually 
 solve (1) if there are only isolated discontinuities away from 
 the solution.)
 
 Note that upper and lower bounds are specified for all the 
 variables and for all the constraints.
 
 An equality constraint can be specified by setting l =u . If 
                                                     i  i    
 certain bounds are not present, the associated elements of l or u
 can be set to special values that will be treated as -infty or 
 +infty.
 
 The user must supply an initial estimate of the solution to (1), 
 together with subroutines that define F(x), c(x) and as many 
 first partial derivatives as possible; unspecified derivatives 
 are approximated by finite differences.
 
 The objective function is defined by subroutine OBJFUN, and the 
 nonlinear constraints are defined by subroutine CONFUN. On every 
 call, these subroutines must return appropriate values of the 
 objective and nonlinear constraints. The user should also provide
 the available partial derivatives. 
 
 E04UCF implements a sequential quadratic programming (SQP) 
 method. 

Parameters

e04ucf

Required Input Arguments:

bl (:)                                real
bu (:)                                real
confun                                function (User-Supplied)
objfun                                function (User-Supplied)
x (:)                                 real

Optional Input Arguments:                       <Default>

ncnln                                 integer  e04ucf03(cjac)
a (:,:)                               real     zeros(1,1)
cjac (:,:)                            real     zeros(max(1,ncnln),length(x))
istate (:)                            integer  zeros(length(bl),1)
clamda (:)                            real     zeros(length(bl),1)
r (:,:)                               real     zeros(length(x))
ifail                                 integer  -1

Output Arguments:

iter                                  integer
c (max(ncnln,1))                      real
objf                                  real
objgrd (:)                            real
x (:)                                 real
cjac (:,:)                            real
istate (:)                            integer
clamda (:)                            real
r (:,:)                               real
ifail                                 integer